package com.hsyt.pfc.support.util;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * @Author: wangze@hsyuntai.com
 * @version 创建时间：2015年7月23日 下午6:56:20
 * @Title: StringUtils.java
 * @package com.hsyt.pfc.support.util
 * @Description:封装基本的字符串操作，继承自apache StringUtils
 * @Copyright 版权归Hundsun 所有
 */

public class StringUtils extends org.apache.commons.lang3.StringUtils {
    /**
     * 验证指定的字符串是否包含在包含逗号分隔符的字符串序列内
     *
     * @param parentStr 包含逗号分隔符的字符串序列
     * @param childStr  指定的字符串
     * @return
     */
    public static boolean containString(String parentStr, String childStr) {
        List<String> listStr = Arrays.asList(parentStr.split(","));//StringTokenizer
        listStr = trimList(listStr);
        return listStr.contains(childStr);
    }

    /**
     * 验证指定的字符串是否包含在包含逗号分隔符的字符串序列内，忽略字符串大小写
     *
     * @param parentStr 包含逗号分隔符的字符串序列
     * @param childStr  指定的字符串
     * @return
     */
    public static boolean containStringIgnoreCase(String parentStr, String childStr) {
        List<String> listStr = Arrays.asList(parentStr.split(","));//StringTokenizer
        listStr = trimList(listStr);
        listStr = toCaseList(listStr, true);
        return listStr.contains(childStr.toUpperCase());
    }

    /**
     * 将目标字符串列表内的字符串忽略前导空白和尾部空白
     *
     * @param listStr 待处理的字符串列表
     * @return 经处理的字符串列表
     */
    public static List<String> trimList(List<String> listStr) {
        List<String> tgtList = new ArrayList<String>();
        for (String s : listStr) {
            if (StringUtils.isNotBlank(s)) tgtList.add(s.trim());
        }
        return tgtList;
    }

    /**
     * 将目标字符串数组内的字符串忽略前导空白和尾部空白
     *
     * @param strArr 待处理的字符串数组
     * @return 经处理的字符串数组
     */
    public static String[] trimArray(String[] strArr) {
        List<String> tarList = new ArrayList<String>();
        for (String s : strArr) {
            if (StringUtils.isNotBlank(s)) tarList.add(s.trim());
        }
        return tarList.toArray(new String[0]);
    }

    /**
     * 将目标字符串数组内的字符串忽略前导空白和尾部空白并在前后增加sequ标识符
     *
     * @param strArr
     * @param sequ
     * @return
     */
    public static String[] trimArray(String[] strArr, CharSequence sequ) {
        List<String> tarList = new ArrayList<String>();
        for (String s : strArr) {
            if (StringUtils.isNotBlank(s)) tarList.add(sequ + s.trim() + sequ);
        }
        return tarList.toArray(new String[0]);
    }

    /**
     * @param listStr     待转换的字符串列表
     * @param toUpperCase true将listStr内字符串全部转换为大写，否则全部小写
     * @return 经转换的字符串列表
     */
    public static List<String> toCaseList(List<String> listStr, boolean toUpperCase) {
        List<String> target = new ArrayList<String>();
        for (String s : listStr) {
            if (toUpperCase) {
                target.add(s.toUpperCase());
            } else {
                target.add(s.toLowerCase());
            }
        }
        return target;
    }

    /**
     * 将指定字符串转换为UTF-8编码格式的字符串
     *
     * @param codeStr 待转换的字符串
     * @return
     */
    public static String transcode(String codeStr) {
        return transcode(codeStr, "iso-8859-1", "utf-8");
    }

    /**
     * @param codeStr
     * @param decodeCharset
     * @param encodeCharset
     * @return
     */
    public static String transcode(String codeStr, String decodeCharset, String encodeCharset) {
        try {
            //encodeUrl = new String(URLEncoder.encode(url, "UTF-8"));
            return new String(codeStr.getBytes(decodeCharset), encodeCharset);
        } catch (UnsupportedEncodingException e) {
        }
        return "";
    }

    /**
     * 从Map中提取键值对拼装URL参数
     *
     * @param urlMap
     * @return
     */
    public static String assembleyURLParam(Map<String, String> urlMap) {
        String urlParamStr = "";
        if (urlMap != null && urlMap.size() > 0) {
            StringBuilder builder = new StringBuilder("?");
            for (Map.Entry<String, String> map : urlMap.entrySet()) {
                builder.append(map.getKey()).append("=").append(map.getValue()).append("&");
            }
            urlParamStr = builder.toString().substring(0, builder.lastIndexOf("&"));
        }
        return urlParamStr;
    }

    /**
     * @param curUpVersion1
     * @param curUpVersion2
     * @return >0  s1>s2  <0 s1<s2
     * @Description: 版本字符串比较 1.0.10  1.0.9
    * @Author: wangze@hsyuntai.com
     * @Date: 2015年12月7日 上午10:54:34
     */
    public static Integer compareToString(String curUpVersion1, String curUpVersion2) {
        String[] cs1 = curUpVersion1.split("\\.");
        String[] cs2 = curUpVersion2.split("\\.");
        int length = 0;
        if (cs1.length <= cs2.length) {
            length = cs1.length;
        } else {
            length = cs2.length;
        }
        try {
            for (int i = 0; i < length; i++) {
                if (Integer.parseInt(cs1[i]) != Integer.parseInt(cs2[i])) {
                    return Integer.parseInt(cs1[i]) - Integer.parseInt(cs2[i]);
                }
            }
        } catch (NumberFormatException e) {
            return 0;
        }
        return cs1.length - cs2.length;
    }

    /**
     * @param stringList List<String>
     * @param joinStr    连接符
     * @return
     * @Description: List<String>转string
     * @Author: wangze@hsyuntai.com
     * @Date: 2016年8月30日 下午3:02:44
     */
    public static String listToString(List<String> stringList, String joinStr) {
        if (stringList == null) {
            return null;
        }
        StringBuilder result = new StringBuilder();
        boolean flag = false;
        for (String string : stringList) {
            if (flag) {
                result.append(joinStr);
            } else {
                flag = true;
            }
            result.append(string);
        }
        return result.toString();
    }
}
